package sensor

import (
	"client2/config"
	"log"
	"time"
)

// SensorManager 传感器管理器
type SensorManager struct {
	readers     []SensorReader
	config      *config.Config
	DataChan    chan SensorData  //公开，外部可访问
	dataHandler func(SensorData) // 数据处理回调函数
}

// HardcodedSensorConfig 写死的传感器配置
type HardcodedSensorConfig struct {
	DeviceID    string
	SensorType  string
	Port        string
	DataLength  int
	Description string
}

// getHardcodedSensorConfigs 获取写死的传感器配置
func getHardcodedSensorConfigs() []HardcodedSensorConfig {
	return []HardcodedSensorConfig{
		{"TEMP_SENSOR", "temperature", "/dev/ttyCH9344USB0", 18, "温度传感器"},
		{"CO_SENSOR", "co", "/dev/ttyCH9344USB1", 9, "一氧化碳传感器"},
		{"CO2_SENSOR", "co2", "/dev/ttyCH9344USB2", 6, "二氧化碳传感器"},
		{"SMOKE_SENSOR", "smoke", "/dev/ttyCH9344USB3", 9, "烟雾传感器"},
		{"CONDUCTIVITY_SENSOR", "conductivity", "/dev/ttyCH9344USB4", 6, "电导率传感器"},
		{"LIQUID_LEVEL_SENSOR", "liquid_level", "/dev/ttyCH9344USB5", 9, "液位传感器"},
		{"FLOW_SENSOR", "flow", "/dev/ttyCH9344USB6", 7, "流速传感器"},
	}
}

// NewSensorManager 创建传感器管理器
func NewSensorManager(cfg *config.Config) *SensorManager {
	var readers []SensorReader

	// 使用写死的传感器配置
	hardcodedConfigs := getHardcodedSensorConfigs()
	log.Printf("使用写死的传感器配置，共 %d 个传感器", len(hardcodedConfigs))

	// 遍历所有写死的传感器配置
	for _, sensorConfig := range hardcodedConfigs {
		// 为每个传感器创建对应的解析器
		parser := NewParser(sensorConfig.SensorType, sensorConfig.DataLength)
		if parser == nil {
			log.Printf("警告: 无法为端口 %s 创建 %s 解析器", sensorConfig.Port, sensorConfig.SensorType)
			continue
		}

		// 使用写死的设备ID
		deviceID := sensorConfig.DeviceID
		log.Printf("使用写死的传感器ID: %s (端口: %s, 类型: %s)", deviceID, sensorConfig.Port, sensorConfig.SensorType)

		// 创建读取器
		reader := NewSerialSensorReaderWithID(sensorConfig.Port, &cfg.Sensor, parser, sensorConfig.DataLength, deviceID, sensorConfig.SensorType)
		if err := reader.Initialize(); err != nil {
			log.Printf("初始化传感器 %s 失败: %v", sensorConfig.Port, err)
			continue
		}

		readers = append(readers, reader)
		log.Printf("成功初始化传感器, 端口: %s (ID: %s, 类型: %s, 数据长度: %d)",
			sensorConfig.Port, deviceID, sensorConfig.SensorType, sensorConfig.DataLength)
	}

	if len(readers) == 0 {
		log.Println("警告: 没有可用的有效传感器，将继续运行基础功能")
	}

	return &SensorManager{
		readers:  readers,
		config:   cfg,
		DataChan: make(chan SensorData, 100),
	}
}

// Close 关闭所有传感器读取器
func (m *SensorManager) Close() {
	for _, reader := range m.readers {
		if err := reader.Close(); err != nil {
			log.Printf("关闭传感器 %s 错误: %v", reader.GetName(), err)
		}
	}
	if m.DataChan != nil {
		close(m.DataChan)
	}
}

// Run 运行传感器管理器（在独立goroutine中）
func (m *SensorManager) Run() {
	if len(m.readers) == 0 {
		log.Println("没有可用传感器，跳过数据读取循环")
		return
	}

	// 主读取循环
	ticker := time.NewTicker(m.config.Sensor.ReadInterval)
	defer ticker.Stop()

	for range ticker.C {
		// 添加 panic 恢复机制，防止单个传感器读取错误导致整个循环崩溃
		func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("❌ 传感器读取循环发生 panic: %v", r)
				}
			}()

			for _, reader := range m.readers {
				data, err := reader.Read()
				if err != nil {
					log.Printf("读取传感器 %s 错误: %v", reader.GetName(), err)
					continue
				}

				for _, sensorData := range data {
					/*
						// 根据传感器类型格式化输出
						switch sensorData.SensorType {
						case "temperature_humidity":
							fmt.Printf("[%s - %s - %s] 温度: %s℃, 湿度: %s%%\n",
								sensorData.Port, sensorData.SensorID, sensorData.Timestamp.Format("2006-01-02 15:04:05"),
								sensorData.Values["temperature"], sensorData.Values["humidity"])
						case "co":
							fmt.Printf("[%s - %s - %s] CO浓度: %.2f MG/M3\n",
								sensorData.Port, sensorData.SensorID, sensorData.Timestamp.Format("2006-01-02 15:04:05"),
								sensorData.Values["concentration"])
						case "co2":
							fmt.Printf("[%s - %s- %s] CO2浓度: %d ppm\n",
								sensorData.Port, sensorData.SensorID, sensorData.Timestamp.Format("2006-01-02 15:04:05"),
								sensorData.Values["concentration"])
						case "smoke":
							fmt.Printf("[%s - %s - %s] 烟雾浓度: %s%%\n",
								sensorData.Port, sensorData.SensorID, sensorData.Timestamp.Format("2006-01-02 15:04:05"),
								sensorData.Values["smoke_level"])
						default:
							fmt.Printf("[%s - %s - %s] 未知传感器数据: %v\n",
								sensorData.Port, sensorData.SensorID, sensorData.Timestamp.Format("2006-01-02 15:04:05"),
								sensorData.Values)
						}
					*/

					// 将数据发送到通道，供main函数使用
					select {
					case m.DataChan <- sensorData:
						// 数据成功发送
					default:
						log.Printf("警告: 数据通道已满，丢弃传感器数据: %v", sensorData)
					}
				}
			}
		}()
	}
}

func (m *SensorManager) Get_num() int {
	return len(m.readers)
}

// HasTemperatureSensor 检查是否存在温度传感器
func (m *SensorManager) HasTemperatureSensor() bool {
	hardcodedConfigs := getHardcodedSensorConfigs()
	for _, config := range hardcodedConfigs {
		if config.SensorType == "temperature" || config.SensorType == "temperature_only" || config.SensorType == "temperature_humidity" {
			log.Printf("发现温度传感器: %s (端口: %s)", config.DeviceID, config.Port)
			return true
		}
	}
	return false
}

// GetTemperatureSensors 获取所有温度传感器的信息
func (m *SensorManager) GetTemperatureSensors() []HardcodedSensorConfig {
	var tempSensors []HardcodedSensorConfig
	hardcodedConfigs := getHardcodedSensorConfigs()

	for _, config := range hardcodedConfigs {
		if config.SensorType == "temperature" || config.SensorType == "temperature_only" || config.SensorType == "temperature_humidity" {
			tempSensors = append(tempSensors, config)
		}
	}

	log.Printf("找到 %d 个温度传感器", len(tempSensors))
	return tempSensors
}

// SetDataHandler 设置数据处理回调函数（用于向后兼容）
func (m *SensorManager) SetDataHandler(handler func(SensorData)) {
	m.dataHandler = handler

	// 启动后台 goroutine 处理 DataChan 中的数据
	go func() {
		// 添加 panic 恢复机制，防止数据处理错误导致 goroutine 崩溃
		defer func() {
			if r := recover(); r != nil {
				log.Printf("❌ 传感器数据处理 goroutine 发生 panic: %v", r)
				// 可以选择重新启动这个 goroutine 或记录错误
			}
		}()

		for data := range m.DataChan {
			if m.dataHandler != nil {
				m.dataHandler(data)
			}
		}
	}()
}
